23 research outputs found
Mungo and StMungo: tools for typechecking protocols in Java
We present two tools that support static typechecking of communica- tion protocols in Java. Mungo associates Java classes with typestate specifications, which are state machines defining permitted sequences of method calls. StMungo translates a communication protocol specified in the Scribble protocol description language into a typestate specification for each role in the protocol by following the message sequence. Role implementations can be typechecked by Mungo to ensure that they satisfy their protocols, and then compiled as usual with javac. We demonstrate the Scribble, StMungo and Mungo toolchain via a typechecked POP3 client that can communicate with a real-world POP3 server
Effects and Effect Handlers for Programmable Inference
Inference algorithms for probabilistic programming are complex imperative
programs with many moving parts. Efficient inference often requires customising
an algorithm to a particular probabilistic model or problem, sometimes called
inference programming. Most inference frameworks are implemented in languages
that lack a disciplined approach to side effects, which can result in
monolithic implementations where the structure of the algorithms is obscured
and inference programming is hard. Functional programming with typed effects
offers a more structured and modular foundation for programmable inference,
with monad transformers being the primary structuring mechanism explored to
date.
This paper presents an alternative approach to programmable inference, based
on algebraic effects, building on recent work that used algebraic effects to
represent probabilistic models. Using effect signatures to specify the key
operations of the algorithms, and effect handlers to modularly interpret those
operations for specific variants, we develop three abstract algorithms, or
inference patterns, representing three important classes of inference:
Metropolis-Hastings, particle filtering, and guided optimisation. We show how
our approach reveals the algorithms' high-level structure, and makes it easy to
tailor and recombine their parts into new variants. We implement the three
inference patterns as a Haskell library, and discuss the pros and cons of
algebraic effects vis-a-vis monad transformers as a structuring mechanism for
modular imperative algorithm design. It should be possible to reimplement our
library in any typed functional language able to emulate effects and effect
handlers
Liveness for Verification
We explore the use of liveness for interactive program verification for a
simple concurrent object language. Our experimental IDE integrates two
(formally dual) kinds of continuous testing into the development environment:
compatibility-checking, which verifies an object's use of other objects, and
compliance-checking, which verifies an object's claim to refine the behaviour
of another object. Source code errors highlighted by the IDE are not static
type errors but the reflection back to the source of runtime errors that occur
in some execution of the system. We demonstrate our approach, and discuss
opportunities and challenges.Comment: 2nd Workshop on Live Programming Systems, LIVE 201
Causally consistent dynamic slicing
We offer a lattice-theoretic account of the problem of dynamic slicing for π-calculus, building on
prior work in the sequential setting. For any particular run of a concurrent program, we exhibit a
Galois connection relating forward slices of the initial configuration to backward slices of the terminal
configuration. We prove that, up to lattice isomorphism, the same Galois connection arises
for any causally equivalent execution, allowing an efficient concurrent implementation of slicing
via a standard interleaving semantics. Our approach has been formalised in the dependentlytyped
programming language Agda
Incremental Relational Lenses
Lenses are a popular approach to bidirectional transformations, a
generalisation of the view update problem in databases, in which we wish to
make changes to source tables to effect a desired change on a view. However,
perhaps surprisingly, lenses have seldom actually been used to implement
updatable views in databases. Bohannon, Pierce and Vaughan proposed an approach
to updatable views called relational lenses, but to the best of our knowledge
this proposal has not been implemented or evaluated to date. We propose
incremental relational lenses, that equip relational lenses with
change-propagating semantics that map small changes to the view to
(potentially) small changes to the source tables. We also present a
language-integrated implementation of relational lenses and a detailed
experimental evaluation, showing orders of magnitude improvement over the
non-incremental approach. Our work shows that relational lenses can be used to
support expressive and efficient view updates at the language level, without
relying on updatable view support from the underlying database.Comment: To appear, ICFP 201
Modular Probabilistic Models via Algebraic Effects
Probabilistic programming languages (PPLs) allow programmers to construct
statistical models and then simulate data or perform inference over them. Many
PPLs restrict models to a particular instance of simulation or inference,
limiting their reusability. In other PPLs, models are not readily composable.
Using Haskell as the host language, we present an embedded domain specific
language based on algebraic effects, where probabilistic models are modular,
first-class, and reusable for both simulation and inference. We also
demonstrate how simulation and inference can be expressed naturally as
composable program transformations using algebraic effect handlers
Proof-relevant pi-calculus
Formalising the pi-calculus is an illuminating test of the expressiveness of
logical frameworks and mechanised metatheory systems, because of the presence
of name binding, labelled transitions with name extrusion, bisimulation, and
structural congruence. Formalisations have been undertaken in a variety of
systems, primarily focusing on well-studied (and challenging) properties such
as the theory of process bisimulation. We present a formalisation in Agda that
instead explores the theory of concurrent transitions, residuation, and causal
equivalence of traces, which has not previously been formalised for the
pi-calculus. Our formalisation employs de Bruijn indices and dependently-typed
syntax, and aligns the "proved transitions" proposed by Boudol and Castellani
in the context of CCS with the proof terms naturally present in Agda's
representation of the labelled transition relation. Our main contributions are
proofs of the "diamond lemma" for residuation of concurrent transitions and a
formal definition of equivalence of traces up to permutation of transitions.Comment: In Proceedings LFMTP 2015, arXiv:1507.0759